/**
 * 心理测评量表题目管理工具
 * 提供对测试题目的增删改查及顺序调整等功能
 * 支持SAS和SDS等多种心理测评量表管理
 */

// 初始化数据库连接和集合引用
const db = wx.cloud.database();
const _ = db.command;
const testQuestionsCollection = db.collection('test_questions');
const util = require('./util.js');

/**
 * 获取测试题目列表
 * 根据测试类型获取对应的测试题目，并按题目序号排序
 * 
 * @param {String} testType 测试类型（SAS、SDS等）
 * @param {Boolean} includeInactive 是否包含未启用的题目
 * @returns {Array} 题目列表
 */
const getTestQuestions = async (testType, includeInactive = false) => {
  try {
    // 构建查询条件，筛选指定类型的题目
    let query = testQuestionsCollection.where({
      testType: testType
    });
    
    // 是否只查询已启用的题目
    if (!includeInactive) {
      query = query.where({
        active: true
      });
    }
    
    // 按题目序号排序，获取查询结果
    const result = await query.orderBy('questionIndex', 'asc').get();
    
    // 检查结果是否有效，无数据则返回默认题目
    if (result.data && result.data.length > 0) {
      return result.data;
    } else {
      console.log('未找到题目，使用默认题目');
      return getDefaultQuestions(testType);
    }
  } catch (error) {
    // 数据库查询出错时记录错误并返回默认题目
    console.error('获取测试题目失败:', error);
    return getDefaultQuestions(testType);
  }
};

/**
 * 获取单个测试题目
 * 根据题目ID查询特定题目的详细信息
 * 
 * @param {String} questionId 题目ID
 * @returns {Object} 题目对象，查询失败返回null
 */
const getTestQuestion = async (questionId) => {
  try {
    const result = await testQuestionsCollection.doc(questionId).get();
    return result.data;
  } catch (error) {
    console.error('获取测试题目失败', error);
    return null;
  }
};

/**
 * 添加测试题目
 * 创建新的测试题目并自动分配序号
 * 
 * @param {Object} question 题目对象，包含内容、选项等
 * @returns {String} 新增题目ID，添加失败返回null
 */
const addTestQuestion = async (question) => {
  try {
    // 如果没有指定questionIndex，则获取当前最大序号+1
    if (!question.questionIndex) {
      // 查询同类型题目中的最大序号
      const maxIndexQuestion = await testQuestionsCollection
        .where({ testType: question.testType })
        .orderBy('questionIndex', 'desc')
        .limit(1)
        .get();
      
      // 计算新题目的序号
      const maxIndex = maxIndexQuestion.data.length > 0 ? 
        maxIndexQuestion.data[0].questionIndex : 0;
      
      question.questionIndex = maxIndex + 1;
    }
    
    // 补充默认字段，如未指定激活状态则默认为启用
    if (question.active === undefined) {
      question.active = true;
    }
    
    // 向数据库添加新题目，并记录创建和更新时间
    const result = await testQuestionsCollection.add({
      data: {
        ...question,
        createTime: db.serverDate(),
        updateTime: db.serverDate()
      }
    });
    
    return result._id;
  } catch (error) {
    console.error('添加测试题目失败', error);
    return null;
  }
};

/**
 * 更新测试题目
 * 修改现有题目的内容、选项或其他属性
 * 
 * @param {String} questionId 题目ID
 * @param {Object} question 更新的题目数据
 * @returns {Boolean} 是否更新成功
 */
const updateTestQuestion = async (questionId, question) => {
  try {
    // 更新题目数据并记录更新时间
    await testQuestionsCollection.doc(questionId).update({
      data: {
        ...question,
        updateTime: db.serverDate()
      }
    });
    return true;
  } catch (error) {
    console.error('更新测试题目失败', error);
    return false;
  }
};

/**
 * 删除测试题目
 * 从数据库中移除指定题目
 * 
 * @param {String} questionId 题目ID
 * @returns {Boolean} 是否删除成功
 */
const deleteTestQuestion = async (questionId) => {
  try {
    await testQuestionsCollection.doc(questionId).remove();
    return true;
  } catch (error) {
    console.error('删除测试题目失败', error);
    return false;
  }
};

/**
 * 调整题目顺序
 * 将指定题目移动到新位置，并自动调整其他题目的序号
 * 
 * @param {String} questionId 题目ID
 * @param {Number} newIndex 新的序号
 * @returns {Boolean} 是否调整成功
 */
const reorderTestQuestion = async (questionId, newIndex) => {
  try {
    // 获取当前题目信息
    const questionResult = await testQuestionsCollection.doc(questionId).get();
    const question = questionResult.data;
    const oldIndex = question.questionIndex;
    const testType = question.testType;
    
    // 如果序号相同，不需要调整
    if (oldIndex === newIndex) {
      return true;
    }
    
    // 获取所有同类型题目，用于后续序号调整
    const allQuestionsResult = await testQuestionsCollection
      .where({ testType: testType })
      .orderBy('questionIndex', 'asc')
      .get();
    const allQuestions = allQuestionsResult.data;
    
    // 根据移动方向调整题目序号
    if (oldIndex < newIndex) {
      // 向后移动：所有中间的题目序号-1
      for (const q of allQuestions) {
        if (q.questionIndex > oldIndex && q.questionIndex <= newIndex && q._id !== questionId) {
          await testQuestionsCollection.doc(q._id).update({
            data: {
              questionIndex: q.questionIndex - 1,
              updateTime: db.serverDate()
            }
          });
        }
      }
    } else {
      // 向前移动：所有中间的题目序号+1
      for (const q of allQuestions) {
        if (q.questionIndex >= newIndex && q.questionIndex < oldIndex && q._id !== questionId) {
          await testQuestionsCollection.doc(q._id).update({
            data: {
              questionIndex: q.questionIndex + 1,
              updateTime: db.serverDate()
            }
          });
        }
      }
    }
    
    // 更新当前题目序号
    await testQuestionsCollection.doc(questionId).update({
      data: {
        questionIndex: newIndex,
        updateTime: db.serverDate()
      }
    });
    
    return true;
  } catch (error) {
    console.error('调整题目顺序失败', error);
    return false;
  }
};

/**
 * 批量导入测试题目
 * 用于一次性导入多个题目，常用于系统初始化
 * 
 * @param {Array} questions 题目数组
 * @returns {Boolean} 是否导入成功
 */
const batchImportQuestions = async (questions) => {
  try {
    // 小程序云开发的事务支持有限，采用循环添加方式
    for (let i = 0; i < questions.length; i++) {
      const question = questions[i];
      // 设置题目序号和激活状态
      question.questionIndex = i + 1;
      question.active = true;
      
      // 添加到数据库并记录时间
      await testQuestionsCollection.add({
        data: {
          ...question,
          createTime: db.serverDate(),
          updateTime: db.serverDate()
        }
      });
    }
    return true;
  } catch (error) {
    console.error('批量导入测试题目失败', error);
    return false;
  }
};

/**
 * 从硬编码数据初始化测试题目
 * 用于系统首次使用时，确保有基础题目可用
 * 
 * @returns {Boolean} 是否初始化成功
 */
const initializeQuestionsFromHardcoded = async () => {
  try {
    // 检查是否已有题目，避免重复初始化
    const existingQuestions = await testQuestionsCollection.count();
    if (existingQuestions.total > 0) {
      console.log('已存在测试题目，跳过初始化');
      return true;
    }
    
    // 硬编码的SAS和SDS题目（从pages/psychological-test/test/test.js中获取）
    const hardcodedData = {
      SAS: {
        name: '焦虑自评量表',
        questions: [
          {
            content: '我感到比平常容易紧张或着急',
            options: [
              { text: '没有或很少时间', score: 1 },
              { text: '小部分时间', score: 2 },
              { text: '相当多时间', score: 3 },
              { text: '绝大部分或全部时间', score: 4 }
            ]
          },
          {
            content: '我无缘无故地感到害怕',
            options: [
              { text: '没有或很少时间', score: 1 },
              { text: '小部分时间', score: 2 },
              { text: '相当多时间', score: 3 },
              { text: '绝大部分或全部时间', score: 4 }
            ]
          }
          // 这里后续需要添加完整的SAS题目
        ]
      },
      SDS: {
        name: '抑郁自评量表',
        questions: [
          {
            content: '我感到情绪沮丧，郁闷',
            options: [
              { text: '没有或很少时间', score: 1 },
              { text: '小部分时间', score: 2 },
              { text: '相当多时间', score: 3 },
              { text: '绝大部分或全部时间', score: 4 }
            ]
          },
          {
            content: '我觉得早晨心情最好',
            options: [
              { text: '没有或很少时间', score: 4 },
              { text: '小部分时间', score: 3 },
              { text: '相当多时间', score: 2 },
              { text: '绝大部分或全部时间', score: 1 }
            ],
            isReverse: true
          }
          // 这里后续需要添加完整的SDS题目
        ]
      }
    };
    
    // 转换SAS题目格式并导入数据库
    const sasQuestions = hardcodedData.SAS.questions.map(q => ({
      testType: 'SAS',
      content: q.content,
      options: q.options,
      isReverse: q.isReverse || false
    }));
    await batchImportQuestions(sasQuestions);
    
    // 转换SDS题目格式并导入数据库
    const sdsQuestions = hardcodedData.SDS.questions.map(q => ({
      testType: 'SDS',
      content: q.content,
      options: q.options,
      isReverse: q.isReverse || false
    }));
    await batchImportQuestions(sdsQuestions);
    
    console.log('初始化测试题目成功');
    return true;
  } catch (error) {
    console.error('初始化测试题目失败', error);
    return false;
  }
};

/**
 * 提供默认题目
 * 在数据库无法访问或题目不存在时使用
 * 
 * @param {String} testType 测试类型
 * @returns {Array} 默认题目列表
 */
function getDefaultQuestions(testType) {
  if (testType === 'SAS') {
    return getSASDefaultQuestions();
  } else if (testType === 'SDS') {
    return getSDSDefaultQuestions();
  }
  return [];
}

/**
 * SAS默认题目
 * 提供焦虑自评量表的基础题目
 * 
 * @returns {Array} SAS默认题目列表
 */
function getSASDefaultQuestions() {
  // 所有题目使用相同的选项
  const defaultOptions = [
    { text: "没有或很少时间", score: 1 },
    { text: "小部分时间", score: 2 },
    { text: "相当多时间", score: 3 },
    { text: "绝大部分或全部时间", score: 4 }
  ];

  // 返回基础题目集合
  return [
    {
      questionIndex: 1,
      content: "我感到比平常更加紧张或焦虑",
      options: defaultOptions,
      isReverse: false
    },
    {
      questionIndex: 2,
      content: "我无缘无故地感到害怕",
      options: defaultOptions,
      isReverse: false
    }
  ];
}

/**
 * SDS默认题目
 * 提供抑郁自评量表的基础题目
 * 
 * @returns {Array} SDS默认题目列表
 */
function getSDSDefaultQuestions() {
  // 所有题目使用相同的选项
  const defaultOptions = [
    { text: "没有或很少时间", score: 1 },
    { text: "小部分时间", score: 2 },
    { text: "相当多时间", score: 3 },
    { text: "绝大部分或全部时间", score: 4 }
  ];

  // 返回基础题目集合
  return [
    {
      questionIndex: 1,
      content: "我感到情绪沮丧、心情低落",
      options: defaultOptions,
      isReverse: false
    },
    {
      questionIndex: 2,
      content: "我感到早晨心情最好",
      options: defaultOptions,
      isReverse: true
    }
  ];
}

// 导出所有函数，供其他模块使用
module.exports = {
  getTestQuestions,
  getTestQuestion,
  addTestQuestion,
  updateTestQuestion,
  deleteTestQuestion,
  reorderTestQuestion,
  batchImportQuestions,
  initializeQuestionsFromHardcoded
}; 